/**
 * 认证管理器 - 处理JWT token的存储、验证和续期
 */
class AuthManager {
    constructor() {
        this.storageKey = 'auth_token';
        this.refreshTokenKey = 'refresh_token';
        this.tokenExpiryKey = 'token_expiry';
        this.rememberUsernameKey = 'remember_username';
    }

    /**
     * 检查用户是否已登录
     */
    isLoggedIn() {
        const token = this.getToken();
        if (!token) {
            return false;
        }
        
        // 检查token是否过期
        if (this.isTokenExpired()) {
            return false;
        }
        
        return true;
    }

    /**
     * 获取存储的token
     */
    getToken() {
        return localStorage.getItem(this.storageKey) || 
               this.getCookie(this.storageKey) || 
               this.getUrlToken();
    }

    /**
     * 从cookie中获取token
     */
    getCookie(name) {
        const cookieToken = document.cookie
            .split('; ')
            .find(row => row.startsWith(`${name}=`));
        return cookieToken ? cookieToken.split('=')[1] : null;
    }

    /**
     * 从URL参数中获取token
     */
    getUrlToken() {
        const urlParams = new URLSearchParams(window.location.search);
        return urlParams.get('token');
    }

    /**
     * 安全的页面跳转
     */
    navigateTo(url) {
        // 如果是登录页面，允许访问
        if (url.includes('/login')) {
            window.location.href = url;
            return;
        }
        
        // 检查登录状态
        if (this.isLoggedIn()) {
            window.location.href = url;
        } else {
            // 保存目标URL，登录后跳转
            sessionStorage.setItem('redirect_url', url);
            window.location.href = '/web/login';
        }
    }

    /**
     * 处理导航点击事件
     */
    handleNavigation(url) {
        // 如果是登录页面，允许访问
        if (url.includes('/login')) {
            return true;
        }
        
        // 检查登录状态
        if (this.isLoggedIn()) {
            return true; // 允许正常跳转
        } else {
            // 保存目标URL，登录后跳转
            sessionStorage.setItem('redirect_url', url);
            window.location.href = '/web/login';
            return false; // 阻止跳转
        }
    }

    /**
     * 检查并清理URL中的token参数
     */
    cleanUrlToken() {
        const url = new URL(window.location);
        if (url.searchParams.has('token')) {
            url.searchParams.delete('token');
            window.history.replaceState({}, '', url);
        }
    }

    /**
     * 检查token是否过期
     */
    isTokenExpired() {
        const expiry = localStorage.getItem(this.tokenExpiryKey);
        if (!expiry) return true;
        
        const expiryTime = parseInt(expiry);
        const bufferTime = 5 * 60 * 1000; // 5分钟缓冲时间
        
        return Date.now() > (expiryTime - bufferTime);
    }

    /**
     * 验证token有效性
     */
    async validateToken() {
        if (!this.isLoggedIn()) {
            return false;
        }

        try {
            const response = await fetch('/api/auth/validate', {
                method: 'POST',
                headers: {
                    'Authorization': `Bearer ${this.getToken()}`,
                    'Content-Type': 'application/json'
                }
            });

            if (response.ok) {
                const data = await response.json();
                if (data.valid) {
                    // 更新token过期时间
                    if (data.expires_in) {
                        this.updateTokenExpiry(data.expires_in);
                    }
                    return true;
                }
            }

            // Token无效，清除登录信息
            this.clearLoginInfo();
            return false;

        } catch (error) {
            console.error('Token验证失败:', error);
            this.clearLoginInfo();
            return false;
        }
    }

    /**
     * 登录成功后保存token
     */
    saveToken(token, refreshToken = null, expiresIn = 1800) {
        // 保存到localStorage
        localStorage.setItem(this.storageKey, token);
        
        // 保存刷新token
        if (refreshToken) {
            localStorage.setItem(this.refreshTokenKey, refreshToken);
        }
        
        // 保存过期时间
        this.updateTokenExpiry(expiresIn);
        
        // 保存到cookie（可选）
        document.cookie = `${this.storageKey}=${token}; path=/; max-age=${expiresIn}; SameSite=Strict`;
    }

    /**
     * 登录成功后处理重定向
     */
    handleLoginSuccess() {
        // 获取之前保存的重定向URL
        const redirectUrl = sessionStorage.getItem('redirect_url');
        
        // 清除保存的重定向URL
        sessionStorage.removeItem('redirect_url');
        
        // 如果有重定向URL，则跳转到该URL
        if (redirectUrl && !redirectUrl.includes('/login')) {
            window.location.href = redirectUrl;
        } else {
            // 默认跳转到分析结果页面
            window.location.href = '/web/analysis-results';
        }
    }

    /**
     * 更新token过期时间
     */
    updateTokenExpiry(expiresIn) {
        const expiryTime = Date.now() + (expiresIn * 1000);
        localStorage.setItem(this.tokenExpiryKey, expiryTime.toString());
    }

    /**
     * 自动续期token
     */
    async refreshToken() {
        const refreshToken = localStorage.getItem(this.refreshTokenKey);
        if (!refreshToken) {
            throw new Error('没有刷新token');
        }

        try {
            const response = await fetch('/api/auth/refresh', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({
                    refresh_token: refreshToken
                })
            });

            if (response.ok) {
                const data = await response.json();
                this.saveToken(data.access_token, data.refresh_token, data.expires_in);
                return true;
            } else {
                throw new Error('Token续期失败');
            }
        } catch (error) {
            console.error('Token续期失败:', error);
            this.clearLoginInfo();
            throw error;
        }
    }

    /**
     * 退出登录
     */
    async logout() {
        try {
            // 调用后端退出接口
            const token = this.getToken();
            if (token) {
                await fetch('/api/auth/logout', {
                    method: 'POST',
                    headers: {
                        'Authorization': `Bearer ${token}`,
                        'Content-Type': 'application/json'
                    }
                });
            }
        } catch (error) {
            console.error('退出登录失败:', error);
        } finally {
            this.clearLoginInfo();
            // 跳转到登录页
            window.location.href = '/web/login';
        }
    }

    /**
     * 清除登录信息
     */
    clearLoginInfo() {
        // 清除localStorage
        localStorage.removeItem(this.storageKey);
        localStorage.removeItem(this.refreshTokenKey);
        localStorage.removeItem(this.tokenExpiryKey);
        localStorage.removeItem(this.rememberUsernameKey);
        
        // 清除cookie
        document.cookie = `${this.storageKey}=; path=/; max-age=0; SameSite=Strict`;
        
        // 清除URL中的token参数
        const url = new URL(window.location);
        url.searchParams.delete('token');
        window.history.replaceState({}, '', url);
    }

    /**
     * 记住用户名
     */
    rememberUsername(username) {
        localStorage.setItem(this.rememberUsernameKey, username);
    }

    /**
     * 获取记住的用户名
     */
    getRememberedUsername() {
        return localStorage.getItem(this.rememberUsernameKey);
    }

    /**
     * 清除记住的用户名
     */
    clearRememberedUsername() {
        localStorage.removeItem(this.rememberUsernameKey);
    }

    /**
     * 获取用户信息
     */
    async getUserInfo() {
        try {
            const response = await fetch('/api/auth/me', {
                method: 'GET',
                headers: {
                    'Authorization': `Bearer ${this.getToken()}`,
                    'Content-Type': 'application/json'
                }
            });

            if (response.ok) {
                return await response.json();
            } else {
                throw new Error('获取用户信息失败');
            }
        } catch (error) {
            console.error('获取用户信息失败:', error);
            return null;
        }
    }

    /**
     * 检查权限
     */
    async hasPermission(permission) {
        try {
            const userInfo = await this.getUserInfo();
            if (!userInfo || !userInfo.permissions) {
                return false;
            }
            return userInfo.permissions.includes(permission);
        } catch (error) {
            console.error('检查权限失败:', error);
            return false;
        }
    }

    /**
     * 检查角色
     */
    async hasRole(role) {
        try {
            const userInfo = await this.getUserInfo();
            if (!userInfo || !userInfo.roles) {
                return false;
            }
            return userInfo.roles.includes(role);
        } catch (error) {
            console.error('检查角色失败:', error);
            return false;
        }
    }

    /**
     * 检查是否为管理员
     */
    async isAdmin() {
        return await this.hasRole('admin') || await this.hasRole('superuser');
    }

    /**
     * 自动token管理（在需要时自动续期）
     */
    async ensureValidToken() {
        if (!this.isLoggedIn()) {
            return false;
        }

        // 如果token即将过期，尝试续期
        if (this.isTokenExpired()) {
            try {
                await this.refreshToken();
                return true;
            } catch (error) {
                console.error('自动续期失败:', error);
                return false;
            }
        }

        return true;
    }

    /**
     * 设置自动token检查
     */
    setupAutoTokenCheck() {
        // 如果已经设置了定时器，先清理
        if (this.tokenCheckInterval) {
            clearInterval(this.tokenCheckInterval);
        }
        
        // 检查是否为登录页面
        const isLoginPage = () => {
            return window.location.pathname === '/web/login' || 
                   window.location.pathname.endsWith('/login');
        };

        // 每5分钟检查一次token状态
        this.tokenCheckInterval = setInterval(async () => {
            // 如果是登录页面，不进行自动检查
            if (isLoginPage()) {
                return;
            }
            
            if (this.isLoggedIn()) {
                const isValid = await this.validateToken();
                if (!isValid) {
                    console.log('Token已失效，跳转到登录页');
                    window.location.href = '/web/login';
                }
            }
        }, 5 * 60 * 1000);

        // 监听页面可见性变化，页面重新可见时检查token
        document.addEventListener('visibilitychange', async () => {
            // 如果是登录页面，不进行自动检查
            if (isLoginPage()) {
                return;
            }
            
            if (!document.hidden && this.isLoggedIn()) {
                const isValid = await this.validateToken();
                if (!isValid) {
                    console.log('Token已失效，跳转到登录页');
                    window.location.href = '/web/login';
                }
            }
        });
    }

    /**
     * 清理所有定时器
     */
    cleanupTimers() {
        if (this.tokenCheckInterval) {
            clearInterval(this.tokenCheckInterval);
            this.tokenCheckInterval = null;
        }
    }
}

// 创建全局实例
window.authManager = new AuthManager();

// 页面加载时设置自动token检查
document.addEventListener('DOMContentLoaded', () => {
    window.authManager.setupAutoTokenCheck();
    // 清理URL中的token参数
    window.authManager.cleanUrlToken();
});

// 添加请求拦截器
(function() {
    const originalFetch = window.fetch;
    
    // 检查是否为登录页面
    const isLoginPage = () => {
        return window.location.pathname === '/web/login' || 
               window.location.pathname.endsWith('/login');
    };
    
    window.fetch = async function(url, options = {}) {
        // 自动添加Authorization头
        if (window.authManager.isLoggedIn()) {
            options = options || {};
            options.headers = options.headers || {};
            
            if (!options.headers.Authorization) {
                options.headers.Authorization = `Bearer ${window.authManager.getToken()}`;
            }
        }
        
        try {
            const response = await originalFetch(url, options);
            
            // 如果返回401错误，尝试续期token
            if (response.status === 401) {
                try {
                    await window.authManager.refreshToken();
                    // 重新发送请求
                    options.headers.Authorization = `Bearer ${window.authManager.getToken()}`;
                    return originalFetch(url, options);
                } catch (refreshError) {
                    console.error('Token续期失败:', refreshError);
                    window.authManager.clearLoginInfo();
                    // 如果不是登录页面，才跳转到登录页
                    if (!isLoginPage()) {
                        window.location.href = '/web/login';
                    }
                    throw refreshError;
                }
            }
            
            return response;
            
        } catch (error) {
            console.error('请求失败:', error);
            throw error;
        }
    };
})();

// 导出AuthManager类（如果需要模块化）
if (typeof module !== 'undefined' && module.exports) {
    module.exports = AuthManager;
}